﻿#pragma once
#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
#include<vector>
#include<map>
#include<string>
#include<assert.h>
using namespace std;

struct Point
{
	int _x;
	int _y;
};

class Date
{
public:
	Date(int year = 1, int month = 1, int day = 1)
		:_year(year)
		, _month(month)
		, _day(day)
	{}

	Date(const Date& d)
		:_year(d._year)
		, _month(d._month)
		, _day(d._day)
	{}
private:
	int _year;
	int _month;
	int _day;
};

//int main()
//{
//	//C++98支持:
//	int a1[] = { 1,2,3,4,5 };
//	int a2[5] = { 0 };
//	Point p1 = { 1,2 };
//
//	//C++11支持:
//	//内置类型
//	int x1 = { 2 };//int x1 = 2
//	//自定义类型
//	Date d1 = { 2025,2,1 };//本质是用{ 2025,2,1 }先构造一个临时对象，临时对象再去拷贝构造d1，编译器优化为{ 2025,2,1 }直接构造初始化d1
//
//	//d2引用的是{ 2025,2,1 }构造的临时对象
//	const Date& d2 = { 2025,2,1 };
//	
//	//C++98支持单参数类型转换，不用{}
//	Date d3 = { 2025 };//C++11
//	Date d4 = 2025;//C++98
//
//	//C++11支持省略=
//	Point p2{ 1,2 };
//	int x2{ 2 };
//	Date d5{ 2025,2,1 };
//	const Date& d6{ 2025,2,1 };
//
//	//{}的便捷性
//	vector<Date> v;
//	v.push_back(d1);
//	v.push_back(Date{ 2025,2,1 });
//	//比起有名和匿名对象,这里直接使用{}更方便
//	v.push_back({ 2025,2,1 });
//
//	return 0;
//}


//int main()
//{
//	std::initializer_list<int> mylist = { 10,20,30 };//临时数组
//
//	//initializer_list对象中存放两个指针begin和end,指向临时数组
//	cout << sizeof(mylist) << endl;//x86下运行结果:8
//
//	//这两个指针的值跟i的地址很接近，说明临时数组存放在栈上
//	int i = 0;
//	cout << &i << endl;
//	cout << mylist.begin() << endl;
//	cout << mylist.end() << endl;
//
//	//使用{}列表时语义的区别
//	vector<int> v1({ 1,2,3,4,5 });//直接构造
//	vector<int> v2 = { 1,2,3,4,5 };//构造临时对象+临时对象拷贝v2,编译器优化为直接构造
//	const vector<int>& v3 = { 1,2,3,4,5 };//引用临时对象,临时对象具有常性,要加const
//
//	//initailizer_list+{}pair对象的隐式类型转换
//	map<string, string> dict = { {"sort","排序"},{"isnert","插入"} };
//
//	//initailizer_list支持赋值
//	v1 = { 10,20,30,40,50 };
//	
//	return 0;
//}

//template <class _Ty>
//remove_reference_t<_Ty>&& move(_Ty&& _Arg)
//{
//	return static_cast<remove_reference_t<_Ty>&&>(_Arg);
//}
//
//int main()
//{
//	//左值:可以取地址,下面的p、b、c、*p、s、s[0]都是左值
//	int* p = new int(0);
//	int b = 1;
//	const int c = b;
//	*p = 10;
//	string s("11111111");
//	s[0] = 'x';
//
//	cout << &c << endl;
//	cout << (void*)&s[0] << endl;
//
//	//左值引用,给左值取别名
//	int& r1 = b;
//	int*& r2 = p;
//	int& r3 = *p;
//	string& r4 = s;
//	char& r5 = s[0];
//
//	//右值:不能取地址,下面的10,x+y,fmin(x+y),string("11111")都是右值
//	double x = 1.1, y = 2.2;
//	10;
//	x + y;
//	fmin(x, y);
//	string("11111");
//	
//	//右值引用,给右值取别名
//	int&& rr1 = 10;
//	double&& rr2 = x + y;
//	double&& rr3 = fmin(x, y);
//	string&& rr4 = string("11111");
//
//	//左值引用不能直接引用右值,但是const左值引用可以引用右值
//	const int& rx1 = 10;
//	const double& rx2 = x + y;
//	const double& rx3 = fmin(x, y);
//	const string& rx4 = string("11111");
//
//	//右值引用不能直接引用左值,但是右值引用可以引用move(左值)
//	int&& rrx1 = move(b);
//	int*&& rrx2 = move(p);
//	int&& rrx3 = move(*p);
//	string&& rrx4 = move(s);//(string&&)s
//
//	//左值引用、右值引用的属性都是左值
//	cout << &r1 << endl;
//	cout << &rr1 << endl;
//
//	//rr1的属性是右值,不能直接被右值引用绑定，move后即可
//	int&& rrx6 = move(rr1);
//
//	return 0;
//}


//int main()
//{
//	string s1 = "Test ";
//	const string& r1 = s1 + s1;//const左值引用可以延长生命周期
//	//r1 += "xxx";//err: const左值引用不能修改
//
//	string&& r2 = s1 + s1;//右值引用也可以延长生命周期
//	r2 += "yyy";//右值引用可以修改
//	cout << r2 << endl;
//
//	return 0;
//}


//template<class T>
//void func(const T& x)
//{}
//
//void f(int& x)
//{
//	cout << "左值引用重载 f(" << x << ")" << endl;
//}
//
//void f(const int& x)
//{
//	cout << "const左值引用重载 f(" << x << ")" << endl;
//}
//
//void f(int&& x)
//{
//	cout << "右值引用重载 f(" << x << ")" << endl;
//}
//
//int main()
//{
//	int i = 1;
//	const int ci = 2;
//
//	f(i);//调用f(int& x)
//	f(ci);//调用f(const int& x)
//	f(3);//调用f(int&& x)，如果没有f(int&&)重载，会调用f(const int&)
//
//	int&& x = 1;
//	f(x);//右值引用本身的属性是左值
//
//	f(move(x));//左值move后变成右值，调用f(int&& x)
//
//	return 0;
//}


namespace zsy
{
	class string
	{
	public:
		typedef char* iterator;
		typedef const char* const_iterator;

		iterator begin()
		{
			return _str;
		}

		iterator end()
		{
			return _str + _size;
		}

		const_iterator begin() const
		{
			return _str;
		}

		const_iterator end() const
		{
			return _str + _size;
		}

		string(const char* str = "")
			:_size(strlen(str))
			, _capacity(_size)
		{
			cout << "string(char* str)-构造" << endl;
			_str = new char[_capacity + 1];
			strcpy(_str, str);
		}

		void swap(string& s)
		{
			std::swap(_str, s._str);
			std::swap(_size, s._size);
			std::swap(_capacity, s._capacity);
		}

		//拷贝构造
		string(const string& s)
			:_str(nullptr)
		{
			cout << "string(const string& s)-拷贝构造" << endl;
			reserve(s._capacity);
			for (auto ch : s)
			{
				push_back(ch);
			}
		}

		//移动构造
		string(string&& s)
		{
			cout << "string(string&& s)-移动构造" << endl;
			//转移掠夺你的资源
			swap(s);
		}

		//拷贝赋值
		string& operator=(const string& s)
		{
			cout << "string& operator=(const string& s)-赋值" << endl;
			if (this != &s)
			{
				_str[0] = '\0';
				_size = 0;
				reserve(s._capacity);
				for (auto ch : s)
				{
					push_back(ch);
				}
			}

			return *this;
		}

		//移动赋值
		string& operator=(string&& s)
		{
			cout << "string& operator=(string&& s)-移动赋值" << endl;
			swap(s);

			return *this;
		}

		~string()
		{
			delete[] _str;
			_str = nullptr;
		}

		char& operator[](size_t pos)
		{
			assert(pos < _size);
			return _str[pos];
		}

		void reserve(size_t n)
		{
			if (n > _capacity)
			{
				char* tmp = new(char[n + 1]);
				if (_str)
				{
					strcpy(tmp, _str);
					delete[] _str;
				}

				_str = tmp;
				_capacity = n;
			}
		}

		void push_back(char ch)
		{
			//扩容
			if (_size >= _capacity)
			{
				size_t newcapacity = _capacity == 0 ? 4 : _capacity * 2;
				reserve(newcapacity);
			}

			_str[_size] = ch;
			++_size;
			_str[_size] = '\0';
		}

		string& operator+=(char ch)
		{
			push_back(ch);

			return *this;
		}

		const char* c_str() const
		{
			return _str;
		}

		size_t size() const
		{
			return _size;
		}

	private:
		char* _str = nullptr;
		size_t _size = 0;
		size_t _capacity = 0;
	};
}

//int main()
//{
//	zsy::string s1("11111");//构造
//	zsy::string s2 = s1;//拷贝构造
//	zsy::string s3 = zsy::string("22222");//构造+移动构造，编译器优化为直接构造
//	zsy::string s4 = move(s1);//移动构造
//
//	return 0;
//}


namespace zsy
{
	string addStrings(string num1, string num2)
	{
		string str;
		int end1 = num1.size() - 1, end2 = num2.size() - 1;
		//进位
		int next = 0;
		while (end1 >= 0 || end2 >= 0)
		{
			int val1 = end1 >= 0 ? num1[end1--] - '0' : 0;
			int val2 = end2 >= 0 ? num2[end2--] - '0' : 0;
			int ret = val1 + val2 + next;
			next = ret / 10;
			ret = ret % 10;
			str += ('0' + ret);
		}

		if (next == 1)
		{
			str += '1';
		}
		reverse(str.begin(), str.end());

		return str;
	}
};

//int main()
//{
//	zsy::string ret = zsy::addStrings("11111", "22222");
//	cout << ret.c_str() << endl;
//	return 0;
//}

int main()
{
	zsy::string ret;
	ret = zsy::addStrings("11111", "22222");
	cout << ret.c_str() << endl;

	return 0;
}
